class Page extends Array {
    constructor({ index, page }) {
        super(...page);
        this.index = index;
    }
    isSame(page) {
        return page.index === this.index;
    }
}
class Pages extends Array {
    // 这里需要 index 的原因是可以跳过某个位置的东西
    // Info = { index, page }
    add(Info) {
        const page = new Page(Info);
        const isRepeat = this.some((oldPage, index) => {
            if (oldPage.isSame(page)) {
                // 重复则覆盖这个位置
                this[index] = oldPage;
                this.size = this.size - oldPage.length + page.length;
                return true;
            }
        });
        if (!isRepeat) {
            // 不重复则添加这个
            this.push(page);
            this.size += page.length;
        }
    }
    delete(index) {
        let PageIndex;
        this.some((oldPage, pageIndex) => {
            if (oldPage.index === index) {
                PageIndex = pageIndex;
                return true;
            }
        });
        this.splice(PageIndex, 1);
    }
    find(index) {
        for (let i of this) {
            if (i.index === index) {
                return i;
            }
        }
        return false;
    }
    clear() {
        this.splice(0, this.length);
    }
    size = 0; // 这个是储存 最小单位 的数量
}

//  在 Vuex 中绑定的东西会被删除函数
async function $to(index) {
    if (this.$lock) {
        console.log("事务锁定中");
        return null;
    } else {
        this.$lock = true;
    }
    let data;
    try {
        if (this.$cache) {
            data = this.$AllPages.find(index);
            if (!data) {
                const resultArray = await this.$getPage(index);
                this.$AllPages.add({ index, page: resultArray });
                data = resultArray;
            }
        } else {
            console.info("未缓存请求", index);
            const resultArray = await this.$getPage(index);
            data = resultArray;
        }

        this.splice(0, this.length, ...data);
        this.index = index;
    } catch (e) {
        console.warn(e);
    }
    this.$lock = false;
}
function $refresh(index) {
    if (index === undefined) index = this.index;
    let data = this.$AllPages.find(index);
    if (data) this.$AllPages.delete(index);
    this.$to(index);
}
function $next() {
    return this.$to(this.index + 1);
}
function $prev() {
    if (this.index - 1 < 0) return false;
    return this.$to(this.index - 1);
}
function $checkout(branchName) {
    if (this.$branch === branchName) return false;
    if (!this.$Query.hasOwnProperty(branchName)) {
        this.$Query[branchName] = new Pages();
    }
    if (this.$branch === "temp") {
        // 如果是 temp 分支，在脱离时将会删除所有的数据
        this.$AllPages.clear();
    }
    this.$branch = branchName;
    this.index = 0;
    this.$to(0);
}
// 分页查询类
// 本体是一个数组，可以被遍历，但是在属性上保存了所有 Pages 的记录，$next 的时候给出下一个的 Page 记录到自身
// 所有实际类继承自它即可

// branch 是每一个不同的搜索结果的查询
// 使用 checkout 可以转换到对应的 branch，而不用重新加载
// temp 分支是用于筛选查询数据的一个分支，主要用于临时查询数据，当从temp分支中切换出来的时候，将会删除原来数据
const getterAndSetter = {
    $AllPages: {
        get() {
            return this.$Query[this.$branch];
        },
    },
    $AllBranch: {
        get() {
            return Object.keys(this.$Query);
        },
    },
};
class Query extends Array {
    constructor(userSetting) {
        super();
        Object.assign(this, userSetting, {
            $to,
            $next,
            $prev,
            $checkout,
            $refresh,
        });
        Object.entries(getterAndSetter).forEach(([key, value]) => {
            Object.defineProperty(this, key, value);
        });
        if (this.$init) {
            this.$init();
        }
    }
    $cache = true;
    $lock = false;
    index = -1; // 用于表示这个是当前 query 第几页

    $branch = "default"; // 用于表示选中的 $Query 的 Pages

    $Query = {
        default: new Pages(),
        temp: new Pages(),
    };
    // 用于获取数据的一个异步函数，返回是一个 数组
    async $getPage(index) {}
}
export default Query;
